Solo-Fast Universal Constructions for Deterministic Abortable Objects

In this paper we study efficient implementations for deterministic abortable objects. Proposed by Hadzilacos and Toueg [8] a deterministic abortable object ensures that if several processes contend to operate on it, it may return a special response abort to indicate that the operation failed. And it guarantees that an aborted operation does not take effect. Operations that do not abort return a response which is legal w.r.t. the sequential specification of the object. Similarly to obstruction-free objects, the behavior of abortable objects degrades when there is contention. On the other hand, abortable objects always return the control to the caller of an operation, and when this happens the caller knows if the operation took place or not. This is an ideal behavior for shared objects [3]. Since they deal with correctness and progress separately, we expect simple and efficient algorithms to implement deterministic abortable objects. Attiya et al. proved that it is impossible to implement these objects only with read/write registers, [3]. Thus, we study implementations that use only read/write registers when there is no contention and use stronger synchronization primitives, e.g., CAS, when contention occurs. These implementations are called solo-fast and are expected to take advantage of the fact that in practice contention is rare. The notion of solo-fast was defined in [3] for step contention : There is step contention when the steps of a process are interleaved with the steps of another process. In the same paper, they prove a linear lower bound on the space complexity of solo-fast implementations of obstruction-free objects. This result also holds for deterministic abortable objects. We consider an asynchronous shared-memory system where n processes communicate through linearizable base objects and can fail by crashing, i.e.; a process can stop taking steps while executing an operation. In this model we study the possibility to implement deterministic abortable objects with a better space complexity than linear if a process is allowed to use strong synchronization primitives even in absence of step contention, provided that its operation is concurrent with another one. This notion of contention is called interval contention [1]. Step contention implies interval contention, the converse is not true. Also, we consider implementations where a crashed process can cause only a finite number of concurrent operations to abort. This property, called non-triviality, is formally defined in [2]. Unfortunately, we prove that some abortable object implementation should have Ω(n) space complexity [4]. The proof of the lower bound is similar to the one presented in [3] and it is not provided in this paper for lack of space. Here we present a solo-fast universal construction for deterministic abortable objects whose space complexity is O(n) if the implemented object has constant size. A universal construction [9] is a methodology for automatically transform any sequential object in a concurrent one. In the following we provide the main ideas of our construction (A detailed description is in Section 2) : Writing operations are applied one at the time. Each process makes a local copy of the object and computes the new state locally. We associate a sequence number to each state. A process that wants to modify the ith state has to compete to win the i + 1th sequence number. A process that does not experience contention uses only read/write registers, while a CAS register is used in case of contention to decide the new state. It may happen that (at most) one process p behaves as if it was running solo, while other processes were competing for the same sequence number. In this case, we use a lightweight helping mechanism to avoid inconsistency : any other process acquires the state proposed by p as its new state. If it succeeds to apply it, it notifies the process p that its state has been applied. Then the helping process aborts. An implementation resulting from our universal construction is wait-free [9], linearizable [11], nontrivial [2], and non-trivial solo-fast (a process p applies some strong primitive when performing an